home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / new.c < prev    next >
C/C++ Source or Header  |  2000-09-26  |  47KB  |  1,996 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                     ATUtilities Online Help                   ** */
  4. /* **            Copright (C) 1992-1993 by Thomas Dreibholz         ** */
  5. /* **                      All rights reserved                      ** */
  6. /* **                                                               ** */
  7. /* ******************************************************************* */
  8.  
  9. #define PAGE_INDEX 1
  10. #define PAGE_TEXT  2
  11.  
  12. #define PAGE_MEMORY 199
  13.  
  14. #include "ATUtilities.h"
  15. /*
  16. #define CreateBoolGadget(win,x,y,w,h,text,id) CreateBoolToggleGadget(0,win,x,y,w,h,text,id)
  17. #define CreateMinGadget(win,x,y,w,h,id) CreateBoolToggleGadget(4,win,x,y,w,h,0L,id)
  18. */
  19. extern struct Library *DiskfontBase;
  20.  
  21. /* feste Strukturen */
  22. UBYTE *HelpName="SYS:PC/ATUtilities/OnlineHelp.prefs";
  23.  
  24. struct TextAttr Opal=
  25. {
  26.  "opal.font",
  27.  9,
  28.  FS_NORMAL,
  29.  FPF_DISKFONT
  30. };
  31.  
  32. struct OHPrefs
  33. {
  34.  UBYTE Cache;
  35.  UBYTE Numbers;
  36.  UBYTE NumInput;
  37.  UBYTE PAL;
  38. };
  39.  
  40. struct Page
  41. {
  42.  UWORD Length;
  43.  UWORD Flags;
  44.  ULONG Offset;
  45.  ULONG TextOffset;
  46.  ULONG GadgetOffset;
  47.  ULONG PictureOffset;
  48. };
  49.  
  50. struct Pages
  51. {
  52.  struct Page Page[1000];
  53. };
  54.  
  55. #define POFFSET(x) hd->Pages->Page[x].PictureOffset
  56. #define GOFFSET(x) hd->Pages->Page[x].GadgetOffset
  57. #define TOFFSET(x) hd->Pages->Page[x].TextOffset
  58. #define OFFSET(x) hd->Pages->Page[x].Offset
  59. #define LENGTH(x) hd->Pages->Page[x].Length
  60. #define FLAGS(x) hd->Pages->Page[x].Flags
  61.  
  62. struct HelpData
  63. {
  64.  struct OHPrefs     OHPrefs;
  65.  struct Screen     *Screen;
  66.  struct Window     *MainWindow;
  67.  struct Window     *IndexWindow;
  68.  struct Window     *TextWindow;
  69.  struct MenuStrip  *MenuStrip;
  70.  struct Menu       *DateiMenu;
  71.  struct Menu       *QVMenu;
  72.  struct Menu       *BilderMenu;
  73.  struct Window     *GadWindow;
  74.  struct Gadget     *PropGadget;
  75.  struct PropInfo   *PropInfo;
  76.  struct RastPort   *MainRastPort;
  77.  struct RastPort   *IndexRastPort;
  78.  struct MsgPort    *MainUserPort;
  79.  struct MsgPort    *IndexUserPort;
  80.  struct MsgPort    *TextUserPort;
  81.  struct MsgPort    *GadUserPort;
  82.  struct TextFont   *OpalFont;
  83.  struct ViewPort   *ViewPort;
  84.  struct MsgPort    *ConPort;
  85.  struct IOStdReq   *ConReq;
  86.  LONG               ConDev;
  87.  struct FileHandle *HelpFile;
  88.  UBYTE             *Memory;
  89.  struct Pages      *Pages;
  90.  ULONG              Picture[100];
  91.  UWORD              Page;
  92.  UWORD              Flags;
  93.  ULONG              MainWindowSM;
  94.  ULONG              IndexWindowSM;
  95.  ULONG              TextWindowSM;
  96.  ULONG              GadWindowSM;
  97.  ULONG              WaitSM;
  98.  UWORD              NextPage[4];
  99.  
  100.  UWORD              LastPage[PAGE_MEMORY+1];
  101.  UBYTE              LastPagePos;
  102.  UBYTE              LastPageSelect;
  103.  UWORD              ShowLastPageBack;
  104.  
  105.  UBYTE              String[200];
  106.  
  107.  BOOL               NTSC;
  108.  UWORD              Rows;
  109.  UWORD              MaxItems;
  110.  
  111.  UWORD              PropDown;
  112.  
  113.  UWORD              CacheOn;
  114.  ULONG              CacheSize;
  115.  LONG               CachePos;
  116.  LONG               CacheLastPos;
  117.  UBYTE             *CacheMemory;
  118.  
  119.  UBYTE              InputCount;
  120.  UWORD              Input[3];
  121.  
  122.  UWORD              IGy;
  123.  UWORD              IGw;
  124.  UWORD              IGs;
  125.  UWORD              IGPCount;
  126.  struct Gadget     *IndexGadgets[64];
  127.  UWORD              IndexGadgetPages[64];
  128.  
  129.  UWORD              MenuPageCount;
  130.  UWORD              MenuNames[25][70];
  131.  UWORD              MenuPages[25];
  132.  
  133.  UBYTE              MenuPicCount;
  134.  UBYTE              MenuPicNames[25][16];
  135.  UBYTE              MenuPics[25];
  136.  
  137.  UWORD              PropBody;
  138.  UWORD              LineCount;
  139.  UWORD              CurrentLine;
  140.  UBYTE             *Lines[2000];
  141. }; 
  142.  
  143. UWORD Colors[]={0x97a,0x222,0xddd,0xff5,0xdd6,0xccc,0xfff,0x22f};
  144.  
  145. BOOL OpenHelp();
  146. VOID CloseHelp();
  147. VOID ConWrite();
  148. VOID RefreshGadWindow();
  149. VOID GetTitle();
  150. VOID LoadPage();
  151. VOID ShowIndexPage();
  152. VOID ShowTextPage();
  153. VOID RemIndexGadgets();
  154. VOID NewProp();
  155. VOID ShowPart();
  156. VOID MakeMenu();
  157. VOID Hinweise();
  158. VOID GetPictures();
  159. VOID Prefs();
  160. LONG CacheRead();
  161. LONG CacheSeek();
  162. VOID LoadAPicture();
  163. VOID AddPage();
  164.  
  165. BOOL ShowPicture();
  166. BOOL DisplayPicture();
  167. UBYTE *GetOpalLine();
  168. UBYTE *GetOpalLine450();
  169. VOID RemoveMenuStrip();
  170. VOID UseMenuStrip();
  171. UBYTE MouseButton();
  172. struct MenuStrip *BuildMenuStrip();
  173. struct Menu      *AddMenu();
  174. struct Menu      *AddItem();
  175.  
  176.  
  177. /* Informationen anzeigen */
  178. VOID ShowInfo(win,scr)
  179.  struct Window *win;
  180.  struct Screen *scr;
  181. {
  182.  WBenchToFront();
  183.  InformationBox("ATUtilities Online Help - Information",
  184.                 "Online Help - Version 2.0",
  185.                 "Copyright (C) 1993 by",
  186.                 "Thomas Dreibholz",
  187.                 "All rights reserved.",
  188.                 "SYS:PC/ATUtilities/Icons/Help");
  189.  ScreenToFront(scr);
  190.  ActivateWindow(win);
  191. }
  192.  
  193.  
  194. /* Online-Hilfe-Funktion */
  195. VOID Help(name,seite)
  196.  UBYTE *name;
  197.  UWORD  seite;
  198. {
  199.  UBYTE                         s[32];
  200.  REGISTER ULONG                Class;
  201.  REGISTER BOOL                 ende,bool;
  202.  REGISTER UWORD                i,j,Code;
  203.  REGISTER UWORD                MenuNum,ItemNum;
  204.  REGISTER ULONG                Signale;
  205.  register struct IntuiMessage *msg;
  206.  register struct HelpData     *hd;
  207.  register struct Gadget       *gad;
  208.  
  209.  if(DiskfontBase==NULL)
  210.   {
  211.    InfoRequest("Keine Diskfont-Library!");
  212.    return;
  213.   }
  214.  
  215.  hd=AllocMem(sizeof(struct HelpData),MEMF_CLEAR|MEMF_PUBLIC);
  216.  if(hd==NULL)
  217.   {
  218.    ErrorRequest(ERROR_ALLOC);
  219.    return;
  220.   }
  221.  
  222.  bool=OpenHelp(hd,name);
  223.  if(bool==TRUE)
  224.   {
  225.    ende=FALSE;
  226.    while(ende==FALSE)
  227.     {
  228.      Signale=Wait(hd->WaitSM);
  229.      if((hd->GadUserPort!=NULL) && (Signale & hd->GadWindowSM))
  230.       {
  231.        msg=GetMsg(hd->GadUserPort);
  232.        while(msg!=NULL)
  233.         {
  234.          Class=msg->Class;
  235.          gad=msg->IAddress;
  236.          ReplyMsg(msg);
  237.          if(Class==GADGETUP)
  238.           {
  239.            j=gad->GadgetID;
  240.            switch(j)
  241.             {
  242.              case 1000:
  243.                if(hd->LastPageSelect>0)
  244.                 {
  245.                  hd->LastPageSelect--;
  246.                  hd->ShowLastPageBack++;
  247.                  LoadPage(hd,hd->LastPage[hd->LastPageSelect],FALSE);
  248.                 }
  249.               break;
  250.              case 2000:
  251.                if(hd->ShowLastPageBack>0)
  252.                 {
  253.                  hd->ShowLastPageBack--;
  254.                  hd->LastPageSelect++;
  255.                  LoadPage(hd,hd->LastPage[hd->LastPageSelect],FALSE);
  256.                 }
  257.               break;
  258.              default:
  259.                LoadPage(hd,hd->NextPage[j],TRUE);
  260.               break;
  261.             }
  262.           }
  263.          else if(Class==ACTIVEWINDOW)
  264.            ActivateWindow(hd->MainWindow);
  265.          msg=GetMsg(hd->GadUserPort);
  266.         }
  267.       }
  268.      if(Signale & hd->MainWindowSM)
  269.       {
  270.        msg=GetMsg(hd->MainUserPort);
  271.        while(msg!=NULL)
  272.         {
  273.          Class=msg->Class;
  274.          Code=msg->Code;
  275.          gad=msg->IAddress;
  276.          ReplyMsg(msg);
  277.          switch(Class)
  278.           {
  279.            case GADGETUP:
  280.             j=gad->GadgetID;
  281.             switch(j)
  282.              {
  283.               case 1:
  284.                 ende=TRUE;
  285.                break;
  286.               case 2:
  287.                 LoadPage(hd,0,TRUE);
  288.                break;
  289.               case 3:
  290.                 if((hd->Flags==PAGE_TEXT)&&(hd->LineCount>hd->Rows))
  291.                  {
  292.                   hd->PropDown=0;
  293.                   j=hd->PropInfo->VertPot/(65535/hd->PropBody);
  294.                   ShowPart(hd,j);
  295.                  }
  296.                break;
  297.              }
  298.             break;
  299.            case GADGETDOWN:
  300.             j=gad->GadgetID;
  301.             switch(j)
  302.              {
  303.               case 3:
  304.                 if((hd->Flags==PAGE_TEXT)&&(hd->LineCount>hd->Rows))
  305.                  {
  306.                   hd->PropDown=1;
  307.                  }
  308.                break;
  309.              }
  310.             break;
  311.            case MOUSEMOVE:
  312.              if(hd->PropDown!=0)
  313.               {
  314.                AbortIO(hd->ConReq);
  315.                j=hd->PropInfo->VertPot/(65535/hd->PropBody);
  316.                ShowPart(hd,j);
  317.               }
  318.             break;
  319.            case MENUPICK:
  320.              MenuNum=MENUNUM(Code);
  321.              ItemNum=ITEMNUM(Code);
  322.              switch(MenuNum)
  323.               {
  324.                case 2:
  325.                  switch(ItemNum)
  326.                   {
  327.                    case 0:
  328.                      ende=TRUE;
  329.                     break;
  330.                    case 2:
  331.                      ShowInfo(hd->MainWindow,hd->Screen);
  332.                     break;
  333.                    case 3:
  334.                      Hinweise(hd);
  335.                     break;
  336.                    case 4:
  337.                      Prefs(hd);
  338.                     break;
  339.                   }
  340.                 break;
  341.                case 1:
  342.                  if(hd->Flags==PAGE_TEXT)
  343.                   {
  344.                    if((hd->MenuPageCount!=0)&&(ItemNum<=hd->MenuPageCount))
  345.                      LoadPage(hd,hd->MenuPages[hd->MenuPageCount-ItemNum-1],TRUE);
  346.                   }
  347.                 break;
  348.                case 0:
  349.                  if((hd->MenuPicCount!=0)&&(ItemNum<=hd->MenuPicCount))
  350.                    LoadAPicture(hd,hd->MenuPics[hd->MenuPicCount-ItemNum-1]);
  351.                  ActivateWindow(hd->MainWindow);
  352.                 break;
  353.               }
  354.             break;
  355.            case VANILLAKEY:
  356.              if(hd->OHPrefs.NumInput)
  357.               {
  358.                if((Code>='0')&&(Code<='9'))
  359.                 {
  360.                  hd->Input[hd->InputCount]=Code;
  361.                  hd->InputCount++;
  362.                  sprintf(&s,"Seiteneingabe: #%c%c%c",hd->Input[0],
  363.                                                      hd->Input[1],
  364.                                                      hd->Input[2]);
  365.                  DrawCNTextBorder(hd->MainWindow,320,10,310,12,&s);
  366.                  if(hd->InputCount>2)
  367.                   {
  368.                    LoadPage(hd,(hd->Input[0]-48)*100+
  369.                                (hd->Input[1]-48)*10+
  370.                                (hd->Input[2]-48),TRUE);
  371.                   }
  372.                 }
  373.               }
  374.             break;
  375.           }
  376.          msg=GetMsg(hd->MainUserPort);
  377.         }
  378.       }
  379.      if(Signale & hd->IndexWindowSM)
  380.       {
  381.        msg=GetMsg(hd->IndexUserPort);
  382.        while(msg!=NULL)
  383.         {
  384.          Class=msg->Class;
  385.          gad=msg->IAddress;
  386.          ReplyMsg(msg);
  387.          if(Class==GADGETUP)
  388.           {
  389.            j=gad->GadgetID;
  390.            LoadPage(hd,hd->IndexGadgetPages[j],TRUE);
  391.           }
  392.          else if(Class==ACTIVEWINDOW)
  393.            ActivateWindow(hd->MainWindow);
  394.          msg=GetMsg(hd->IndexUserPort);
  395.         }
  396.       }
  397.      if(Signale & hd->TextWindowSM)
  398.       {
  399.        msg=GetMsg(hd->TextUserPort);
  400.        while(msg!=NULL)
  401.         {
  402.          Class=msg->Class;
  403.          ReplyMsg(msg);
  404.          if(Class==ACTIVEWINDOW)
  405.            ActivateWindow(hd->MainWindow);
  406.          msg=GetMsg(hd->TextUserPort);
  407.         }
  408.       }
  409.     }
  410.   }
  411.  CloseHelp(hd);
  412.  FreeMem(hd,sizeof(struct HelpData));
  413. }
  414.  
  415.  
  416. BOOL OpenHelp(hd,name)
  417.  struct HelpData *hd;
  418.  UBYTE           *name;
  419. {
  420.  register struct FileHandle *fh;
  421.  UBYTE                       c;
  422.  WORD                        a,i;
  423.  LONG                        b;
  424.  static struct NewScreen HelpScreen=
  425.   {
  426.    0,0,640,256,3,
  427.    0,1,
  428.    HIRES,
  429.    CUSTOMSCREEN,
  430.    NULL,
  431.    NULL,NULL,NULL
  432.   };
  433.  static struct NewWindow MainWindowDef=
  434.   {
  435.    0,0,640,256,
  436.    0,2,
  437.    GADGETUP|MENUPICK|GADGETDOWN|MOUSEMOVE|VANILLAKEY,
  438.    ACTIVATE|BORDERLESS,
  439.    NULL,NULL,NULL,NULL,NULL,
  440.    10,16,640,256,
  441.    CUSTOMSCREEN
  442.   };
  443.  static struct NewWindow IndexWindowDef=
  444.   {
  445.    11,26,582,210,
  446.    0,1,
  447.    GADGETUP|ACTIVEWINDOW,
  448.    BORDERLESS,
  449.    NULL,NULL,NULL,NULL,NULL,
  450.    10,16,640,256,
  451.    CUSTOMSCREEN
  452.   };
  453.  static struct NewWindow TextWindowDef=
  454.   {
  455.    12,27,580,208,
  456.    0,1,
  457.    ACTIVEWINDOW,
  458.    NOCAREREFRESH|BORDERLESS,
  459.    NULL,NULL,NULL,NULL,NULL,
  460.    10,16,640,256,
  461.    CUSTOMSCREEN
  462.   };
  463.  
  464.  hd->ConDev=-1L;
  465.  
  466.  hd->HelpFile=Open(name,MODE_OLDFILE);
  467.  if(hd->HelpFile==NULL)
  468.   {
  469.    MultiRequest("Kann Hilfedatei nicht öffnen:",name,"Okay",NULL);
  470.    return(FALSE);
  471.   }
  472.  
  473.  hd->OpalFont=GetOpalFont();
  474.  if(hd->OpalFont==NULL)
  475.   {
  476.    InfoRequest("Opal-Font fehlt!");
  477.    return(FALSE);
  478.   }
  479.  
  480.  fh=Open(HelpName,MODE_OLDFILE);
  481.  if(fh!=NULL)
  482.   {
  483.    Read(fh,&hd->OHPrefs,sizeof(struct OHPrefs));
  484.    Close(fh);
  485.   }
  486.  
  487.  if(hd->OHPrefs.PAL==0)
  488.   {
  489.    hd->NTSC=TRUE;
  490.    hd->Rows=18;
  491.    hd->MaxItems=18;
  492.    HelpScreen.Height=200;
  493.    MainWindowDef.Height=200;
  494.    IndexWindowDef.Height=154;
  495.    TextWindowDef.Height=152;
  496.   }
  497.  else
  498.   {
  499.    hd->NTSC=FALSE;
  500.    hd->Rows=25;
  501.    hd->MaxItems=24;
  502.   }
  503.  
  504.  hd->Screen=OpenScreen(&HelpScreen);
  505.  if(hd->Screen==NULL)
  506.   {
  507.    InfoRequest("Kann Screen nicht öffnen!");
  508.    return(FALSE);
  509.   }
  510.  
  511.  hd->ViewPort=&hd->Screen->ViewPort;
  512.  LoadRGB4(hd->ViewPort,&Colors,8);
  513.  
  514.  MainWindowDef.Screen=hd->Screen;
  515.  IndexWindowDef.Screen=hd->Screen;
  516.  TextWindowDef.Screen=hd->Screen;
  517.  
  518.  hd->IndexWindow=OpenWindow(&IndexWindowDef);
  519.  if(hd->IndexWindow==NULL)
  520.   {
  521.    InfoRequest("Kann Fenster nicht öffnen!");
  522.    return(FALSE);
  523.   }
  524.  
  525.  hd->TextWindow=OpenWindow(&TextWindowDef);
  526.  if(hd->TextWindow==NULL)
  527.   {
  528.    InfoRequest("Kann Fenster nicht öffnen!");
  529.    return(FALSE);
  530.   }
  531.  
  532.  hd->MainWindow=OpenWindow(&MainWindowDef);
  533.  if(hd->MainWindow==NULL)
  534.   {
  535.    InfoRequest("Kann Fenster nicht öffnen!");
  536.    return(FALSE);
  537.   }
  538.  
  539.  hd->MainRastPort=hd->MainWindow->RPort;
  540.  hd->IndexRastPort=hd->IndexWindow->RPort;
  541.  hd->MainUserPort=hd->MainWindow->UserPort;
  542.  hd->IndexUserPort=hd->IndexWindow->UserPort;
  543.  hd->TextUserPort=hd->TextWindow->UserPort;
  544.  hd->MainWindowSM=(1L<<hd->MainUserPort->mp_SigBit);
  545.  hd->IndexWindowSM=(1L<<hd->IndexUserPort->mp_SigBit);
  546.  hd->TextWindowSM=(1L<<hd->TextUserPort->mp_SigBit);
  547.  hd->MainWindow->UserData=NULL;
  548.  hd->IndexWindow->UserData=NULL;
  549.  hd->TextWindow->UserData=NULL;
  550.  
  551.  SetFont(hd->MainRastPort,hd->OpalFont);
  552.  SetFont(hd->IndexRastPort,hd->OpalFont);
  553.  
  554.  CreateBoolGadget(hd->MainWindow,10,10,150,12,"Ende",1);
  555.  CreateBoolGadget(hd->MainWindow,165,10,150,12,"Index",2);
  556.  if(hd->NTSC==FALSE) i=211; else i=155;
  557.  hd->PropGadget=CreatePropGadget(hd->MainWindow,600,25,30,i,0,0,0,(65535/10),3);
  558.  hd->PropInfo=hd->PropGadget->SpecialInfo;
  559.  DrawNBorder(hd->MainWindow,10,25,584,i);
  560.  
  561.  SetAPen(hd->MainRastPort,3);
  562.  WriteText(hd->MainRastPort,40,40,"ATUtilities Online-Hilfe - Version 2.0");
  563.  WriteText(hd->MainRastPort,40,60,"Hilfedatei wird bearbeitet.");
  564.  WriteText(hd->MainRastPort,40,80,"Bitte warten...");
  565.  
  566.  hd->ConPort=CreatePort("onlinehelp-console.port",0L);
  567.  if(hd->ConPort==NULL)
  568.   {
  569.    InfoRequest("Kann MsgPort nicht erstellen!");
  570.    return(FALSE);
  571.   }
  572.  
  573.  hd->ConReq=CreateExtIO(hd->ConPort,sizeof(struct IOStdReq));
  574.  if(hd->ConReq==NULL)
  575.   {
  576.    InfoRequest("Kann IOStdReq nicht erstellen!");
  577.    return(FALSE);
  578.   }
  579.  
  580.  hd->ConReq->io_Data=hd->TextWindow;
  581.  hd->ConReq->io_Length=sizeof(struct Window);
  582.  
  583.  hd->ConDev=OpenDevice("console.device",0L,hd->ConReq,0L);
  584.  if(hd->ConDev!=0)
  585.   {
  586.    InfoRequest("Kann Console-Device nicht öffnen!");
  587.    return(FALSE);
  588.   }
  589.  
  590.  ConWrite(hd,"\x9b");
  591.  ConWrite(hd,"0;33;40m");
  592.  
  593.  if(hd->OHPrefs.Cache!=0)
  594.   {
  595.    Seek(hd->HelpFile,0,OFFSET_END);
  596.    hd->CacheSize=Seek(hd->HelpFile,0,OFFSET_BEGINNING);
  597.    hd->CacheMemory=AllocMem(hd->CacheSize,MEMF_CLEAR|MEMF_PUBLIC);
  598.    if(hd->CacheMemory!=NULL)
  599.     {
  600.      b=Read(hd->HelpFile,hd->CacheMemory,hd->CacheSize);
  601.      if(b==hd->CacheSize) hd->CacheOn=1;
  602.     }
  603.   }
  604.  
  605.  hd->Pages=AllocMem(sizeof(struct Pages),MEMF_CLEAR|MEMF_PUBLIC);
  606.  if(hd->Pages==NULL)
  607.   {
  608.    ErrorRequest(ERROR_ALLOC);
  609.    return(FALSE);
  610.   }
  611.  
  612.  hd->Memory=AllocMem(50000,MEMF_CLEAR|MEMF_PUBLIC);
  613.  if(hd->Memory==NULL)
  614.   {
  615.    ErrorRequest(ERROR_ALLOC);
  616.    return(FALSE);
  617.   }
  618.  
  619.  CacheSeek(hd,-4,OFFSET_END);
  620.  CacheRead(hd,&b,4L);
  621.  CacheSeek(hd,b,OFFSET_BEGINNING);
  622.  for(i=0;i<1000;i++)
  623.   {
  624.    CacheRead(hd,&c,1L);
  625.    if(c!=0)
  626.     {
  627.      CacheRead(hd,&a,2L);
  628.      CacheRead(hd,&b,4L);
  629.      LENGTH(i)=a;
  630.      OFFSET(i)=b;
  631.      FLAGS(i)=c;
  632.      CacheRead(hd,&b,4L);
  633.      TOFFSET(i)=b;
  634.      CacheRead(hd,&b,4L);
  635.      GOFFSET(i)=b;
  636.      CacheRead(hd,&b,4L);
  637.      POFFSET(i)=b;
  638.     }
  639.   }
  640.  for(i=0;i<100;i++)
  641.   {
  642.    CacheRead(hd,&hd->Picture[i],4L);
  643.   }
  644.  
  645.  hd->MenuStrip=BuildMenuStrip(hd->MainWindow,7,AUTOBACKPEN);
  646.  if(hd->MenuStrip==NULL)
  647.   {
  648.    InfoRequest("Kein Speicher für Menu!");
  649.    return(FALSE);
  650.   }
  651.  
  652.  hd->Page=12345;
  653.  LoadPage(hd,0,TRUE);
  654.  return(TRUE);
  655. }
  656.  
  657.  
  658. VOID CloseHelp(hd)
  659.  struct HelpData *hd;
  660. {
  661.  
  662.  if(hd->MenuStrip) RemoveMenuStrip(hd->MenuStrip,TRUE);
  663.  if(hd->ConDev==0) CloseDevice(hd->ConReq);
  664.  if(hd->GadWindow) DeleteStdWindow(hd->GadWindow);
  665.  if(hd->TextWindow) DeleteStdWindow(hd->TextWindow);
  666.  if(hd->IndexWindow)
  667.   {
  668.    RemIndexGadgets(hd);
  669.    DeleteStdWindow(hd->IndexWindow);
  670.   }
  671.  if(hd->MainWindow) DeleteStdWindow(hd->MainWindow);
  672.  if(hd->Screen) CloseScreen(hd->Screen);
  673.  if(hd->ConReq) DeleteExtIO(hd->ConReq);
  674.  if(hd->ConPort) DeletePort(hd->ConPort);
  675.  if(hd->Pages) FreeMem(hd->Pages,sizeof(struct Pages));
  676.  if(hd->Memory) FreeMem(hd->Memory,50000);
  677.  if(hd->CacheMemory) FreeMem(hd->CacheMemory,hd->CacheSize);
  678.  if(hd->OpalFont) CloseFont(hd->OpalFont);
  679.  if(hd->HelpFile) Close(hd->HelpFile);
  680. }
  681.  
  682.  
  683. VOID ConWrite(hd,text)
  684.  struct HelpData *hd;
  685.  UBYTE           *text;
  686. {
  687.  hd->ConReq->io_Data=text;
  688.  hd->ConReq->io_Length=strlen(text);
  689.  hd->ConReq->io_Command=CMD_WRITE;
  690.  SendIO(hd->ConReq);
  691. }
  692.  
  693.  
  694. VOID RefreshGadWindow(hd)
  695.  struct HelpData *hd;
  696. {
  697.  WORD i;
  698.  static struct NewWindow GadWindowDef=
  699.   {
  700.    0,238,640,15,
  701.    0,1,
  702.    GADGETUP|ACTIVEWINDOW,
  703.    BORDERLESS,
  704.    NULL,NULL,NULL,NULL,NULL,
  705.    10,10,640,256,
  706.    CUSTOMSCREEN
  707.   };
  708.  
  709.  if(hd->NTSC==TRUE) GadWindowDef.TopEdge=182;
  710.  if(hd->GadWindow!=NULL)
  711.    DeleteStdWindow(hd->GadWindow);
  712.  GetTitle(hd,hd->Page);
  713.  DrawMNTextBorder(hd->MainWindow,320,10,310,12,hd->Memory);
  714.  
  715.  GadWindowDef.Screen=hd->Screen;
  716.  hd->GadWindow=OpenWindow(&GadWindowDef);
  717.  if(hd->GadWindow!=NULL)
  718.   {
  719.    SetFont(hd->GadWindow->RPort,hd->OpalFont);
  720.    hd->GadUserPort=hd->GadWindow->UserPort;
  721.    hd->GadWindowSM=(1L<<hd->GadUserPort->mp_SigBit);
  722.    for(i=0;i<=3;i++) hd->NextPage[i]=0xFFFF;
  723.  
  724.    if(hd->Page>0)
  725.     {
  726.      for(i=(hd->Page-1);i>=0;i--)
  727.        if(FLAGS(i)==PAGE_INDEX)
  728.         { hd->NextPage[0]=i; break; }
  729.     }
  730.  
  731.    if(hd->Page!=0) hd->NextPage[3]=0;
  732.    if(hd->Page<999)
  733.     {
  734.      for(i=(hd->Page+1);i<=999;i++)
  735.        if(FLAGS(i)==PAGE_INDEX)
  736.         { hd->NextPage[3]=i; break; }
  737.     }
  738.  
  739.    if(hd->Page>0)
  740.     {
  741.      for(i=(hd->Page-1);i>=0;i--)
  742.       {
  743.        if(FLAGS(i)!=0)
  744.         {
  745.          if(FLAGS(i)==PAGE_TEXT)
  746.            hd->NextPage[1]=i;
  747.          break;
  748.         }
  749.       }
  750.     }
  751.  
  752.    if(hd->Page<999)
  753.     {
  754.      for(i=(hd->Page+1);i<=999;i++)
  755.       {
  756.        if(FLAGS(i)!=0)
  757.         {
  758.          if(FLAGS(i)==PAGE_TEXT)
  759.            hd->NextPage[2]=i;
  760.          break;
  761.         }
  762.       }
  763.     }
  764.  
  765.    for(i=0;i<=3;i++)
  766.     {
  767.      if(hd->NextPage[i]!=0xFFFF)
  768.       {
  769.        GetTitle(hd,hd->NextPage[i]);
  770.        CreateMBoolGadget(hd->GadWindow,38+(i*143),1,135,12,hd->Memory,i);
  771.       }
  772.     }
  773.    if(hd->LastPageSelect>0)
  774.      CreateBoolGadget(hd->GadWindow,10,1,22,12,"«",1000);
  775.    if(hd->ShowLastPageBack>0)
  776.      CreateBoolGadget(hd->GadWindow,608,1,22,12,"»",2000);
  777.   }
  778.  else
  779.   {
  780.    hd->GadWindowSM=0;
  781.    hd->GadUserPort=NULL;
  782.   }
  783.  hd->WaitSM=hd->GadWindowSM+hd->MainWindowSM+hd->IndexWindowSM+hd->TextWindowSM;
  784. }
  785.  
  786.  
  787. VOID GetTitle(hd,p)
  788.  struct HelpData *hd;
  789.  LONG             p;
  790. { 
  791.  LONG i,o;
  792.  
  793.  i=OFFSET(p);
  794.  if(i!=0)
  795.   {
  796.    o=CacheSeek(hd,i,OFFSET_BEGINNING);
  797.    if(hd->OHPrefs.Numbers==0)
  798.     {
  799.      CacheRead(hd,hd->Memory,1024L);
  800.     }
  801.    else
  802.     {
  803.      sprintf(hd->Memory,"#%03ld: ",p);
  804.      CacheRead(hd,&hd->Memory[6],1024L);
  805.     }
  806.    CacheSeek(hd,o,OFFSET_BEGINNING);
  807.   }
  808.  else hd->Memory[0]=0x00;
  809. }
  810.  
  811.  
  812. VOID LoadPage(hd,num,add)
  813.  struct HelpData *hd;
  814.  UWORD            num;
  815.  BOOL             add;
  816. {
  817.  
  818.  hd->InputCount=0;
  819.  hd->Input[1]='-';
  820.  hd->Input[2]='-';
  821.  if(num==hd->Page) return;
  822.  if(OFFSET(num)!=0)
  823.   {
  824.    hd->Page=num;
  825.    hd->Flags=FLAGS(num);
  826.    if(add==TRUE) AddPage(hd);
  827.    RemIndexGadgets(hd);
  828.    switch(hd->Flags)
  829.     {
  830.      case PAGE_INDEX:
  831.        NewProp(hd,1);
  832.        ShowIndexPage(hd,num);
  833.       break;
  834.      case PAGE_TEXT:
  835.        ShowTextPage(hd,num);
  836.       break;
  837.     }
  838.   }
  839.  else
  840.   {
  841.    DisplayBeep(hd->Screen);
  842.    DisplayBeep(hd->Screen);
  843.   }
  844. }
  845.  
  846.  
  847. VOID ShowIndexPage(hd,num)
  848.  struct HelpData *hd;
  849.  UWORD            num;
  850. {
  851.  UBYTE *m;
  852.  LONG   i,j,max;
  853.  UWORD  x,y,w,xx,yy;
  854.  UWORD  wort;
  855.  UBYTE  c;
  856.  
  857.  x=15; y=11;
  858.  j=TOFFSET(num);
  859.  if(j!=0)
  860.   {
  861.    i=LENGTH(num);
  862.    CacheSeek(hd,j,OFFSET_BEGINNING);
  863.    CacheRead(hd,hd->Memory,i);
  864.  
  865.  /* ----- Testausgabe -------------------------------------------------- */
  866.    SetAPen(hd->IndexRastPort,3);
  867.    m=hd->Memory;
  868.    for(j=0;j<i;j++)
  869.     {
  870.      c=m[j];
  871.      if(c==0x00)
  872.       {
  873.        x=15;
  874.        y+=10;
  875.       }
  876.      else
  877.       {
  878.        Move(hd->IndexRastPort,x,y);
  879.        Text(hd->IndexRastPort,&c,1L);
  880.        x=x+TextLength(hd->IndexRastPort,&c,1L);
  881.       }
  882.     }
  883.   }
  884.  
  885.  /* ----- Gadgets ------------------------------------------------------ */
  886.  j=GOFFSET(num);
  887.  if(j!=0)
  888.   {
  889.    CacheSeek(hd,j,OFFSET_BEGINNING);
  890.    j=0; y-=5;
  891.    CacheRead(hd,&wort,2L);
  892.    while((wort!=0xFFFF)&&(j<=63))
  893.     {
  894.      hd->IndexGadgetPages[j]=wort;
  895.      j++;
  896.      CacheRead(hd,&wort,2L);
  897.     }
  898.    hd->IGPCount=j;
  899.  
  900.    if(hd->NTSC==FALSE) max=198; else max=142;
  901.    hd->IGy=(max-y)/27;
  902.    hd->IGs=hd->IGPCount/hd->IGy;
  903.    hd->IGw=((552-((hd->IGs-1)*5))/hd->IGs);
  904.  
  905.    x=15;
  906.    for(i=0;i<hd->IGPCount;i++)
  907.     {
  908.      if(hd->IndexGadgetPages[i]!=2000)
  909.       {
  910.        GetTitle(hd,hd->IndexGadgetPages[i]);
  911.        hd->IndexGadgets[i]=CreateMBoolGadget(hd->IndexWindow,x,y,hd->IGw,12,hd->Memory,i);
  912.        x+=hd->IGw+5;
  913.        if(x>550) { x=15; y+=15; }
  914.       }
  915.      else
  916.       {
  917.        if(x>15)
  918.         {
  919.          x=15; y+=15;
  920.         }
  921.        y+=10;
  922.       }
  923.     }
  924.   }
  925.  else hd->IGPCount=0;
  926.  GetPictures(hd,num);
  927.  
  928.  /* ----- GadWindow öffnen --------------------------------------------- */
  929.  
  930.  WindowToFront(hd->IndexWindow);
  931.  RefreshGadWindow(hd);
  932.  MakeMenu(hd);
  933. }
  934.  
  935.  
  936. VOID GetPictures(hd,num)
  937.  struct HelpData *hd;
  938.  UWORD            num;
  939. {
  940.  UBYTE          byte;
  941.  REGISTER ULONG o;
  942.  
  943.  o=POFFSET(num);
  944.  if(o!=0)
  945.   {
  946.    CacheSeek(hd,o,OFFSET_BEGINNING);
  947.    CacheRead(hd,&byte,1L);
  948.    while((byte!=0xFF)&&(hd->MenuPicCount<=hd->MaxItems))
  949.     {
  950.      hd->MenuPics[hd->MenuPicCount]=byte;
  951.      hd->MenuPicCount++;
  952.      CacheRead(hd,&byte,1L);
  953.     }
  954.   }
  955.  else hd->MenuPicCount=0;
  956. }
  957.  
  958.  
  959. VOID ShowTextPage(hd,num)
  960.  struct HelpData *hd;
  961.  UWORD            num;
  962. {
  963.  UBYTE          *m;
  964.  UBYTE           byte;
  965.  UWORD           wort;
  966.  REGISTER UWORD  i,j,k;
  967.  REGISTER ULONG  o;
  968.  
  969.  hd->MenuPageCount=0;
  970.  o=GOFFSET(num);
  971.  if(o!=0)
  972.   {
  973.    CacheSeek(hd,o,OFFSET_BEGINNING);
  974.    CacheRead(hd,&wort,2L);
  975.    while((wort!=0xFFFF)&&(hd->MenuPageCount<=hd->MaxItems))
  976.     {
  977.      hd->MenuPages[hd->MenuPageCount]=wort;
  978.      hd->MenuPageCount++;
  979.      CacheRead(hd,&wort,2L);
  980.     }
  981.    for(j=0;j<hd->MenuPageCount;j++)
  982.     {
  983.      if(hd->MenuPages[j]!=2000)
  984.       {
  985.        GetTitle(hd,hd->MenuPages[j]);
  986.        if((strlen(hd->Memory))>60) hd->Memory[59]=0x00;
  987.        strcpy(&hd->MenuNames[j],hd->Memory);
  988.       }
  989.     }
  990.   }
  991.  else hd->MenuPageCount=0;
  992.  
  993.  GetPictures(hd,num);
  994.  MakeMenu(hd);
  995.  
  996.  RefreshGadWindow(hd);
  997.  hd->CurrentLine=0xFFFF;
  998.  hd->LineCount=0;
  999.  for(i=0;i<2000;i++) hd->Lines[i]=NULL;
  1000.  
  1001.  j=LENGTH(num);
  1002.  CacheSeek(hd,TOFFSET(num),OFFSET_BEGINNING);
  1003.  CacheRead(hd,hd->Memory,j);
  1004.  
  1005.  i=0;
  1006.  while(i<j)
  1007.  {
  1008.   hd->Lines[hd->LineCount]=&hd->Memory[i];
  1009.   i+=(strlen(&hd->Memory[i])+1);
  1010.   hd->LineCount++;
  1011.  } 
  1012.  
  1013.  ShowPart(hd,0);
  1014.  
  1015.  if(hd->LineCount>hd->Rows)
  1016.    hd->PropBody=hd->LineCount-hd->Rows;
  1017.  else
  1018.    hd->PropBody=1;
  1019.  NewProp(hd,hd->PropBody);
  1020.  WindowToFront(hd->TextWindow);
  1021. }
  1022.  
  1023.  
  1024. VOID ShowPart(hd,part)
  1025.  struct HelpData *hd;
  1026.  UWORD            part;
  1027. {
  1028.  UBYTE          s[6];
  1029.  REGISTER BYTE  test;
  1030.  REGISTER UWORD i,j,k;
  1031.  
  1032.  if(part==hd->CurrentLine) return;
  1033.  
  1034.  if(!(hd->LineCount<=hd->Rows))
  1035.   {
  1036.    if(part>(hd->LineCount-hd->Rows)) part=hd->LineCount-hd->Rows;
  1037.  
  1038.    /*  part            = Zeile, ab der gelistet werden soll
  1039.        hd->CurrentLine = Zeile, ab der gelistet wird          */
  1040.  
  1041.    if(part>hd->CurrentLine)
  1042.      { test=3; if(part-hd->CurrentLine>=hd->Rows) test=1; }
  1043.    else if(part<hd->CurrentLine)
  1044.      { test=4; if(hd->CurrentLine-part>=hd->Rows) test=1; }
  1045.    else if(part==hd->CurrentLine)
  1046.      { test=1; }
  1047.  
  1048.    switch(test)
  1049.     {
  1050.      case 1:
  1051.        hd->CurrentLine=part;
  1052.        ConWrite(hd,"\f");
  1053.        for(i=part;i<part+hd->Rows;i++)
  1054.         {
  1055.          ConWrite(hd,hd->Lines[i]);
  1056.          ConWrite(hd,"\n");
  1057.         }
  1058.       break;
  1059.      case 3:
  1060.        j=part-hd->CurrentLine;
  1061.        k=hd->CurrentLine+hd->Rows;
  1062.        for(i=k;i<(k+j);i++)
  1063.         {
  1064.          ConWrite(hd,hd->Lines[i]);
  1065.          ConWrite(hd,"\n");
  1066.         }
  1067.        hd->CurrentLine+=j;
  1068.       break;
  1069.      case 4:
  1070.        j=hd->CurrentLine-part;
  1071.        k=hd->CurrentLine;
  1072.        ConWrite(hd,"\x9b");
  1073.        ConWrite(hd,"H");
  1074.        for(i=(k-j);i<k;i++)
  1075.         {
  1076.          ConWrite(hd,"\x9b");
  1077.          ConWrite(hd,"L");
  1078.          ConWrite(hd,hd->Lines[i]);
  1079.          ConWrite(hd,"\n");
  1080.         }
  1081.        sprintf(&s,"%ldH",(hd->Rows+1));
  1082.        ConWrite(hd,"\x9b");
  1083.        ConWrite(hd,&s);
  1084.        ConWrite(hd,"\x9b");
  1085.        ConWrite(hd,"M");
  1086.        hd->CurrentLine-=j;
  1087.       break;
  1088.     }
  1089.   }
  1090.  else
  1091.   {
  1092.    ConWrite(hd,"\f");
  1093.    for(i=0;i<hd->LineCount;i++)
  1094.     {
  1095.      ConWrite(hd,hd->Lines[i]);
  1096.      ConWrite(hd,"\n");
  1097.     }
  1098.   }
  1099. }
  1100.  
  1101.  
  1102. VOID RemIndexGadgets(hd)
  1103.  struct HelpData *hd;
  1104. {
  1105.  UBYTE          i;
  1106.  struct Gadget *gad;
  1107.  
  1108.  for(i=0;i<64;i++)
  1109.   {
  1110.    gad=hd->IndexGadgets[i];
  1111.    if(gad!=NULL)
  1112.     {
  1113.      RemoveGadget(hd->IndexWindow,gad);
  1114.      hd->IndexGadgets[i]=NULL;
  1115.      hd->IndexGadgetPages[i]=0;
  1116.     }
  1117.   }
  1118.  if(hd->IndexWindow->UserData!=NULL)
  1119.   {
  1120.    FreeRemember(&hd->IndexWindow->UserData,TRUE);
  1121.    hd->IndexWindow->UserData=NULL;
  1122.   }
  1123.  SetAPen(hd->IndexRastPort,0);
  1124.  RectFill(hd->IndexRastPort,0,0,582,210);
  1125. }
  1126.  
  1127.  
  1128. VOID NewProp(hd,v)
  1129.  struct HelpData *hd;
  1130.  UWORD            v;
  1131. {
  1132.  
  1133.  ModifyProp(hd->PropGadget,hd->MainWindow,NULL,
  1134.             AUTOKNOB|PROPBORDERLESS|FREEVERT,0,0,0,65535/v);
  1135. }
  1136.  
  1137.  
  1138.  
  1139. struct MenuStrip
  1140. {
  1141.  struct Window   *Window;
  1142.  struct TextAttr  TextAttr;
  1143.  UBYTE            FrontPen;
  1144.  UBYTE            BackPen;
  1145.  
  1146.  struct Menu     *LastMenu;
  1147.  struct MenuItem *LastItem;
  1148.  struct MenuItem *LastSubItem;
  1149.  struct Remember *Remember;
  1150. };
  1151.  
  1152. /* MenuStrip Grundstruktur erstellen */
  1153. struct MenuStrip *BuildMenuStrip(win,fp,bp)
  1154.  struct Window   *win;
  1155.  UWORD            fp,bp;
  1156. {
  1157.  register struct MenuStrip *ms;
  1158.  register struct RastPort  *rp;
  1159.  
  1160.  ms=AllocMem(sizeof(struct MenuStrip),MEMF_CLEAR|MEMF_PUBLIC);
  1161.  if(ms!=NULL)
  1162.   {
  1163.    ms->Window=win;
  1164.    rp=win->RPort;
  1165.    ms->TextAttr.ta_Name=rp->Font->tf_Message.mn_Node.ln_Name;
  1166.    ms->TextAttr.ta_YSize=rp->Font->tf_YSize;
  1167.    ms->TextAttr.ta_Flags=rp->Font->tf_Flags;
  1168.    ms->TextAttr.ta_Style=rp->AlgoStyle;
  1169.    ms->FrontPen=fp;
  1170.    ms->BackPen=bp;
  1171.   }
  1172.  return(ms);
  1173. }
  1174.  
  1175. struct Menu *AddMenu(ms,x,w,name)
  1176.  struct MenuStrip *ms;
  1177.  UWORD             x,w;
  1178.  UBYTE            *name;
  1179. {
  1180.  register struct Menu *me;
  1181.  
  1182.  me=AllocRemember(&ms->Remember,sizeof(struct Menu),MEMF_CLEAR|MEMF_PUBLIC);
  1183.  if(me!=NULL)
  1184.   {
  1185.    me->LeftEdge=x;
  1186.    me->TopEdge=0;
  1187.    me->Width=w;
  1188.    me->Height=10;
  1189.    me->Flags=MENUENABLED;
  1190.    me->MenuName=name;
  1191.    me->NextMenu=ms->LastMenu;
  1192.    ms->LastMenu=me;
  1193.    ms->LastItem=NULL;
  1194.    ms->LastSubItem=NULL;
  1195.   }
  1196.  return(me);
  1197. }
  1198.  
  1199. struct MenuItem *AddItem(ms,name,w,cmd,enabled,highcomp)
  1200.  struct MenuStrip *ms;
  1201.  UBYTE            *name;
  1202.  UWORD             w;
  1203.  UBYTE             cmd;
  1204.  BOOL              enabled,highcomp;
  1205. {
  1206.  register struct Menu      *me;
  1207.  register struct MenuItem  *mi;
  1208.  register struct IntuiText *it;
  1209.  
  1210.  me=ms->LastMenu;
  1211.  if(me!=NULL)
  1212.   {
  1213.    mi=AllocRemember(&ms->Remember,sizeof(struct MenuItem)+sizeof(struct IntuiText),MEMF_CLEAR|MEMF_PUBLIC);
  1214.    if(mi!=NULL)
  1215.     {
  1216.      it=(ULONG)mi+(ULONG)sizeof(struct MenuItem);
  1217.  
  1218.      if(ms->LastItem!=NULL)
  1219.        mi->TopEdge=ms->LastItem->TopEdge+10;
  1220.      else
  1221.        mi->TopEdge=0;
  1222.      mi->LeftEdge=0;
  1223.      mi->Width=w;
  1224.      mi->Height=10;
  1225.      mi->Flags=ITEMTEXT;
  1226.      if(enabled) mi->Flags |= ITEMENABLED;
  1227.      if(highcomp) mi->Flags |= HIGHCOMP; else mi->Flags |= HIGHNONE;
  1228.      if(cmd!=0)
  1229.       {
  1230.        mi->Flags |= COMMSEQ;
  1231.        mi->Command=cmd;
  1232.       }
  1233.      mi->ItemFill=it;
  1234.      it->LeftEdge=AUTOLEFTEDGE;
  1235.      it->TopEdge=1;
  1236.      it->DrawMode=JAM1;
  1237.      it->FrontPen=ms->FrontPen;
  1238.      it->BackPen=ms->BackPen;
  1239.      it->ITextFont=&ms->TextAttr;
  1240.      it->IText=name;
  1241.      mi->NextItem=ms->LastItem;
  1242.      ms->LastItem=mi;
  1243.      ms->LastSubItem=NULL;
  1244.      me->FirstItem=mi;
  1245.     }
  1246.   }
  1247.  return(mi);
  1248. }
  1249.  
  1250. VOID UseMenuStrip(ms)
  1251.  struct MenuStrip *ms;
  1252. {
  1253.  
  1254.  if(ms->LastMenu!=NULL) SetMenuStrip(ms->Window,ms->LastMenu);
  1255. }
  1256.  
  1257. VOID RemoveMenuStrip(ms,bool)
  1258.  struct MenuStrip *ms;
  1259.  BOOL              bool;
  1260. {
  1261.  ClearMenuStrip(ms->Window);
  1262.  if(ms->Remember!=NULL) FreeRemember(&ms->Remember,TRUE);
  1263.  ms->Remember=NULL;
  1264.  ms->LastMenu=NULL;
  1265.  ms->LastItem=NULL;
  1266.  ms->LastSubItem=NULL;
  1267.  if(bool==TRUE) FreeMem(ms,sizeof(struct MenuStrip));
  1268. }
  1269.  
  1270. UBYTE *GetOpalLine()
  1271. {
  1272.  return((UBYTE *)"·········································································");
  1273. }
  1274.  
  1275. UBYTE *GetOpalLine450()
  1276. {
  1277.  return((UBYTE *)"···············································································································");
  1278. }
  1279.  
  1280. VOID MacFormat(hd,tex,x)
  1281.  struct HelpData *hd;
  1282.  UBYTE           *tex;
  1283.  UWORD            x;
  1284. {
  1285.  REGISTER UWORD i,j,k,l;
  1286.  
  1287.  k=strlen(tex);
  1288.  l=TextLength(hd->MainRastPort,tex,k);
  1289.  if(l>x)
  1290.   {
  1291.    i=0;
  1292.    j=TextLength(hd->MainRastPort,"...",3);
  1293.    l=j;
  1294.    do
  1295.     {
  1296.      j+=TextLength(hd->MainRastPort,&tex[i],1L);
  1297.      i++;
  1298.     } while(j<x);
  1299.    tex[i]=0x00;
  1300.    strcat(tex,"...");
  1301.   }
  1302. }
  1303.  
  1304.  
  1305. VOID MakeMenu(hd)
  1306.  struct HelpData *hd;
  1307. {
  1308.  REGISTER UWORD i,j;
  1309.  
  1310.  RemoveMenuStrip(hd->MenuStrip,FALSE);
  1311.  hd->DateiMenu=AddMenu(hd->MenuStrip,5,150,"Datei");
  1312.  AddItem(hd->MenuStrip,"Einstellunden ändern",300,'E',TRUE,TRUE);
  1313.  AddItem(hd->MenuStrip,"Bedienungshinweise",300,'B',TRUE,TRUE);
  1314.  AddItem(hd->MenuStrip,"Information",300,'I',TRUE,TRUE);
  1315.  AddItem(hd->MenuStrip,GetOpalLine(),300,0,FALSE,FALSE);
  1316.  AddItem(hd->MenuStrip,"Hilfe beenden",300,'Q',TRUE,TRUE);
  1317.  hd->QVMenu=AddMenu(hd->MenuStrip,160,150,"Querverweise");
  1318.  if((hd->Flags==PAGE_TEXT)&&(hd->MenuPageCount>0))
  1319.   {
  1320.    for(i=0;i<hd->MenuPageCount;i++)
  1321.     {
  1322.      if(hd->MenuPages[i]!=2000)
  1323.       {
  1324.        MacFormat(hd,&hd->MenuNames[i],430);
  1325.        AddItem(hd->MenuStrip,&hd->MenuNames[i],450,0,TRUE,TRUE);
  1326.       }
  1327.      else AddItem(hd->MenuStrip,GetOpalLine450(),450,0,FALSE,FALSE);
  1328.     }
  1329.   }
  1330.  else AddItem(hd->MenuStrip,"Nicht verfügbar",300,0,TRUE,FALSE);
  1331.  hd->BilderMenu=AddMenu(hd->MenuStrip,315,150,"Bilder");
  1332.  if(hd->MenuPicCount>0)
  1333.   {
  1334.    for(i=0;i<hd->MenuPicCount;i++)
  1335.     {
  1336.      if(hd->MenuPics[i]!=200)
  1337.       {
  1338.        sprintf(&hd->MenuPicNames[i],"Abbildung #%ld",hd->MenuPics[i]+1);
  1339.        AddItem(hd->MenuStrip,&hd->MenuPicNames[i],300,0,TRUE,TRUE);
  1340.       }
  1341.      else AddItem(hd->MenuStrip,GetOpalLine(),300,0,FALSE,FALSE);
  1342.     }
  1343.   }
  1344.  else AddItem(hd->MenuStrip,"Nicht verfügbar",300,0,TRUE,FALSE);
  1345.  UseMenuStrip(hd->MenuStrip);
  1346.  ActivateWindow(hd->MainWindow);
  1347. }
  1348.  
  1349.  
  1350. UBYTE *String[]=
  1351. {
  1352.  "",
  1353.  "\x9b1;33;40m\x9b4;33;40mDie Bedienung des Online-Hilfesystems\x9b0;33;40m",
  1354.  "",
  1355.  "",
  1356.  "",
  1357.  "\x9b4;33;40mDie Auswahl von Seiten\x9b0;33;40m",
  1358.  "",
  1359.  "",
  1360.  "Beim Aufruf des Hilfesystems wird zuerst der Hauptindex geladen. Durch",
  1361.  "Klicken auf die Gadgets im Index gelangt man zu den entsprechenden",
  1362.  "Seiten.",
  1363.  "",
  1364.  "Am unteren Bildschirmrand befindet sich mindestens ein Gadget; maximal",
  1365.  "jedoch sechs. Mit ihnen kann zur nächsten bzw. vorhergehenden Seite ge-",
  1366.  "wechselt werden oder die zuletzt angezeigten Seiten erneut sichten.",
  1367.  "",
  1368.  "Gadget-Positionen und ihre Funktionen",
  1369.  "",
  1370.  "[«] [......] [......] [......] [......] [»]",
  1371.  " |     |        |        |        |      |",
  1372.  " |     |        |        |        |      +-- Umkehrung von \"«\"",
  1373.  " |     |        |        |        +-- nächste Indexseite",
  1374.  " |     |        |        +-- nächste Textseite",
  1375.  " |     |        +-- vorhergehende Textseite",
  1376.  " |     +-- vorhergehende Indexseite",
  1377.  " +-- zuletzt gezeigte Seite sichten",
  1378.  "",
  1379.  "",
  1380.  "",
  1381.  "\x9b4;33;40mDie Seitentypen\x9b0;33;40m",
  1382.  "",
  1383.  "",
  1384.  "Indexseiten:",
  1385.  "",
  1386.  "Auf Indexseiten befinden sich Gadgets, die zu den entsprechenden Text-",
  1387.  "seiten führen.",
  1388.  "",
  1389.  "",
  1390.  "Textseiten:",
  1391.  "",
  1392.  "Auf diesen Seiten stehen die Hilfstexte. Ist der Text größer als der",
  1393.  "im Textfenster zur Verfügung stehende Platz, so läßt sich der Text-",
  1394.  "ausschnitt mit dem Proportional-Gadget am rechten Bildschirmrand ver-",
  1395.  "schieben.",
  1396.  "Besitzt die Seite Querverweise auf andere Seiten, so sind diese im",
  1397.  "Menü \"Querverweise\" aufgelistet. Durch Anwahl des entsprechenden",
  1398.  "Menüpunktes wird die Seite geladen.",
  1399.  "Gleiches gilt für Bilder und Diagramme im Menü \"Bilder\".",
  1400.  "",
  1401.  "",
  1402.  "",
  1403.  "\x9b4;33;40mDas Datei-Menü\x9b0;33;40m",
  1404.  "",
  1405.  "",
  1406.  "Der Menüpunkt \"Einstellungen ändern\"",
  1407.  "",
  1408.  "Hier lassen sich die Grundeinstellungen des Hilfesystems ändern:",
  1409.  "",
  1410.  "Cache-Modus: Die Hilfedatei wird beim Start komplett in den Haupt-",
  1411.  "             speicher geladen. Bei Systemen mit wenig Speicher kann",
  1412.  "             der Modus ausgeschaltet werden. Bei jeder neuen Seite",
  1413.  "             wird dann vom Datenträger nachgeladen.",
  1414.  "",
  1415.  "PAL-Modus: Es wird statt des amerikanischen NTSC-Videosystems",
  1416.  "           (600x200 Pixel) das europäische PAL-System (640x256 Pixel)",
  1417.  "           benutzt."
  1418.  "",
  1419.  "Seitennummern: Zusätzlich zum Seitentitel wird auch die Seitennummer",
  1420.  "               angezeigt. Über diese Nummern läuft die gesamte Seiten-",
  1421.  "               verwaltung; deshalb kann diese Funktion beim Einbau der",
  1422.  "               Online-Hilfe in eigene Programme sinnvoll sein. Für den",
  1423.  "               normalen Gebrauch werden diese Nummern nicht benötigt,",
  1424.  "               da die Seitenauswahl über die Maus läuft.",
  1425.  "",
  1426.  "SN-Eingabe: Ist diese Funktion eingeschaltet, so kann eine Seitennummer",
  1427.  "            direkt eingegeben werden: Wurde die erste Ziffer gedrückt,",
  1428.  "            so erscheint rechts oben neben dem Index-Gadget statt der",
  1429.  "            Seitentitelanzeige die Nummerneingabeanzeige. Die direkte",
  1430.  "            Seiteneingabe ist wie auch die Seitennummernanzeige nur",
  1431.  "            für Entwicklungszwecke gedacht und wird deshalb bei Nor-",
  1432.  "            malgebrauch nicht benötigt.",
  1433.  "",
  1434.  "",
  1435.  "Der Menüpunkt \"Bedienungshinweise\"",
  1436.  "",
  1437.  "Hiermit wird dieser Text angezeigt.",
  1438.  "",
  1439.  "",
  1440.  "Der Menüpunkt \"Information\"",
  1441.  "",
  1442.  "Hiermit werden Informationen über das Hilfesystem, die Version und",
  1443.  "den noch freien Speicher im Amiga und auf einer eventuell vorhan-",
  1444.  "denen PC/AT-Brückenkarte angezeigt.",
  1445.  "",
  1446.  "",
  1447.  "Der Menüpunkt \"Hilfe beenden\"",
  1448.  "",
  1449.  "Hiermit wird das Hilfesystem geschlossen und in das Anwendungs-",
  1450.  "programm zurückgekehrt.",
  1451.  "",
  1452.  "",
  1453.  "",
  1454.  "\x9b4;33;40mDas Querverweise-Menü\x9b0;33;40m",
  1455.  "",
  1456.  "In diesem Menü stehen Querverweise auf andere, zum Thema relevante",
  1457.  "Seiten. Sie können durch Anwahl des entsprechendes Menüpunktes",
  1458.  "gesichtet werden. Querverweise sind nicht auf allen Seiten.",
  1459.  "",
  1460.  "",
  1461.  "",
  1462.  "\x9b4;33;40mDas Bilder-Menü\x9b0;33;40m",
  1463.  "",
  1464.  "In diesem Menü befinden sich Bilder, die durch Anwahl der Menüpunkte",
  1465.  "angezeigt werden. Bilder sind, wie Querverweise, nicht auf allen",
  1466.  "Seiten.",
  1467.  NULL
  1468. };
  1469.  
  1470.  
  1471. VOID Hinweise(hd)
  1472.  struct HelpData *hd;
  1473. {
  1474.  REGISTER UWORD i;
  1475.  
  1476.  WindowToFront(hd->TextWindow);
  1477.  RemIndexGadgets(hd);
  1478.  hd->Flags=PAGE_TEXT;
  1479.  hd->Page=1001;
  1480.  hd->CurrentLine=0xFFFF;
  1481.  i=0;
  1482.  while(String[i]!=NULL)
  1483.   {
  1484.    hd->Lines[i]=String[i];
  1485.    i++;
  1486.   }
  1487.  hd->LineCount=i;
  1488.  for( ;i<2000;i++) hd->Lines[i]=NULL;
  1489.  ShowPart(hd,0);
  1490.  hd->PropBody=hd->LineCount-hd->Rows;
  1491.  NewProp(hd,hd->PropBody);
  1492.  WindowToFront(hd->TextWindow);
  1493. }
  1494.  
  1495.  
  1496. VOID Prefs(hd)
  1497.  struct HelpData *hd;
  1498. {
  1499.  REGISTER UWORD                i,j;
  1500.  register struct FileHandle   *fh;
  1501.  register struct Window       *win;
  1502.  register struct RastPort     *rp;
  1503.  register struct Gadget       *g1,*g2,*g3,*g4;
  1504.  static struct NewWindow PrefsWindowDef=
  1505.   {
  1506.    75,75,450,90,
  1507.    0,1,
  1508.    CLOSEWINDOW,
  1509.    ACTIVATE|WINDOWDRAG|WINDOWCLOSE,
  1510.    NULL,NULL,"Online-Hilfe - Einstellungen",NULL,NULL,
  1511.    10,16,640,256,
  1512.    CUSTOMSCREEN
  1513.   };
  1514.  
  1515.  PrefsWindowDef.Screen=hd->Screen;
  1516.  win=OpenWindow(&PrefsWindowDef);
  1517.  if(win!=NULL)
  1518.   {
  1519.    win->UserData=NULL;
  1520.    rp=win->RPort;
  1521.    SetFont(rp,hd->OpalFont);
  1522.    if(hd->OHPrefs.Cache==0)
  1523.      g1=CreateNToggleGadget(win,15,15,410,12,"Cache für Hilfedatei anlegen",1);
  1524.    else
  1525.      g1=CreateSToggleGadget(win,15,15,410,12,"Cache für Hilfedatei anlegen",1);
  1526.    if(hd->OHPrefs.PAL==0)
  1527.      g4=CreateNToggleGadget(win,15,30,410,12,"Europäisches PAL-Videosystem",4);
  1528.    else
  1529.      g4=CreateSToggleGadget(win,15,30,410,12,"Europäisches PAL-Videosystem",4);
  1530.    SetAPen(rp,3);
  1531.    WriteText(rp,20,52,"Spezialeinstellungen:");
  1532.    if(hd->OHPrefs.Numbers==0)
  1533.      g2=CreateNToggleGadget(win,15,57,410,12,"Anzeige mit Seitennummern",2);
  1534.    else
  1535.      g2=CreateSToggleGadget(win,15,57,410,12,"Anzeige mit Seitennummern",2);
  1536.    if(hd->OHPrefs.NumInput==0)
  1537.      g3=CreateNToggleGadget(win,15,72,410,12,"Direkte Seitennummereingabe",3);
  1538.    else
  1539.      g3=CreateSToggleGadget(win,15,72,410,12,"Direkte Seitennummereingabe",3);
  1540.    WaitPort(win->UserPort);
  1541.    ReplyMsg(GetMsg(win->UserPort));
  1542.    if(g1->Flags & SELECTED) hd->OHPrefs.Cache=1; else hd->OHPrefs.Cache=0;
  1543.    if(g2->Flags & SELECTED) hd->OHPrefs.Numbers=1; else hd->OHPrefs.Numbers=0;
  1544.    if(g3->Flags & SELECTED) hd->OHPrefs.NumInput=1; else hd->OHPrefs.NumInput=0;
  1545.    if(g4->Flags & SELECTED) hd->OHPrefs.PAL=1; else hd->OHPrefs.PAL=0;
  1546.    DeleteStdWindow(win);
  1547.    fh=Open(HelpName,MODE_NEWFILE);
  1548.    if(fh!=NULL)
  1549.     {
  1550.      Write(fh,&hd->OHPrefs,sizeof(struct OHPrefs));
  1551.      Close(fh);
  1552.     }
  1553.   }
  1554. }
  1555.  
  1556.  
  1557. LONG CacheRead(hd,mem,len)
  1558.  struct HelpData *hd;
  1559.  UBYTE           *mem;
  1560.  ULONG            len;
  1561. {
  1562.  
  1563.  if(hd->CacheOn==0)
  1564.   {
  1565.    return(Read(hd->HelpFile,mem,len));
  1566.   }
  1567.  
  1568.  CopyMem(&hd->CacheMemory[hd->CachePos],mem,len);
  1569.  hd->CachePos+=len;
  1570.  return(len);
  1571. }
  1572.  
  1573.  
  1574. LONG CacheSeek(hd,pos,offset)
  1575.  struct HelpData *hd;
  1576.  LONG             pos;
  1577.  LONG             offset;
  1578. {
  1579.  
  1580.  if(hd->OHPrefs.Cache==0)
  1581.   {
  1582.    return(Seek(hd->HelpFile,pos,offset));
  1583.   }
  1584.  
  1585.  hd->CacheLastPos=hd->CachePos;
  1586.  switch(offset)
  1587.   {
  1588.    case OFFSET_BEGINNING:
  1589.      hd->CachePos=pos;
  1590.     break;
  1591.    case OFFSET_END:
  1592.      hd->CachePos=hd->CacheSize+pos;
  1593.     break;
  1594.   }
  1595.  return(hd->CacheLastPos);
  1596. }
  1597.  
  1598.  
  1599. VOID LoadAPicture(hd,num)
  1600.  struct HelpData *hd;
  1601.  UBYTE            num;
  1602. {
  1603.  LONG                        o;
  1604.  ULONG                       size;
  1605.  UBYTE                       byte;
  1606.  REGISTER UBYTE             *mem;
  1607.  register struct FileHandle *fh;
  1608.  
  1609.  o=hd->Picture[num];
  1610.  if(o!=NULL)
  1611.   {
  1612.    CacheSeek(hd,o,OFFSET_BEGINNING);
  1613.    CacheRead(hd,&byte,1L);
  1614.    CacheRead(hd,&size,4L);
  1615.    if(byte==0)
  1616.     {
  1617.      CacheRead(hd,&hd->String,199);
  1618.      hd->String[199]=0x00;
  1619.      ShowPicture(&hd->String);
  1620.     }
  1621.    else
  1622.     {
  1623.      if(hd->CacheOn!=0)
  1624.       {
  1625.        DisplayPicture(&hd->CacheMemory[hd->CachePos],size);
  1626.       }
  1627.      else
  1628.       {
  1629.        mem=AllocMem(size,MEMF_CLEAR|MEMF_PUBLIC);
  1630.        if(mem!=NULL)
  1631.         {
  1632.          CacheRead(hd,mem,size);
  1633.          DisplayPicture(mem,size);
  1634.          FreeMem(mem,size);
  1635.         }
  1636.       }
  1637.     }
  1638.   }
  1639. }
  1640.  
  1641.  
  1642. struct BMHD
  1643. {
  1644.  UWORD w,h,x,y;
  1645.  UBYTE BitPlanes;
  1646.  UBYTE Masking;
  1647.  UBYTE Compression;
  1648.  UBYTE pad;
  1649.  UWORD TransCol;
  1650.  UBYTE XA,YA;
  1651.  UWORD Width,Height;
  1652. };
  1653.  
  1654. struct ColReg
  1655. {
  1656.  UBYTE Red;
  1657.  UBYTE Green;
  1658.  UBYTE Blue;
  1659. };
  1660.  
  1661. struct CAMG
  1662. {
  1663.  UWORD pad;
  1664.  UWORD ViewModes;
  1665. };
  1666.  
  1667. struct CRNG
  1668. {
  1669.  UWORD  pad;
  1670.  UWORD  rate;
  1671.  UWORD  active;
  1672.  UBYTE  low,high;
  1673. };
  1674.  
  1675. struct RInfo
  1676. {
  1677.  UBYTE *Memory;
  1678.  ULONG  Pos;
  1679.  ULONG  Max;
  1680. };
  1681.  
  1682. ULONG Lesen(ri,m,l)
  1683.  struct RInfo *ri;
  1684.  UBYTE        *m;
  1685.  ULONG         l;
  1686. {
  1687.  if((ri->Pos+l)>ri->Max) l=(ri->Max-ri->Pos);
  1688.  CopyMem(&ri->Memory[ri->Pos],m,l);
  1689.  ri->Pos+=l;
  1690.  return(l);
  1691. }
  1692.  
  1693. VOID Jump(ri,l)
  1694.  struct RInfo *ri;
  1695.  ULONG         l;
  1696. {
  1697.  if((ri->Pos+l)>ri->Max) l=(ri->Max-ri->Pos);
  1698.  ri->Pos+=l;
  1699. }
  1700.  
  1701. UBYTE ColorCount[]={1,2,4,8,16,32,32,32,32};
  1702.  
  1703. BOOL DisplayPicture(mem,len)
  1704.  UBYTE *mem;
  1705.  LONG   len;
  1706. {
  1707.  struct NewScreen        ns;
  1708.  UBYTE                   Buffer[300];
  1709.  ULONG                   l;
  1710.  BOOL                    BMHDFlag,BODYFlag,CMAPFlag,CAMGFlag,CRNGFlag,FoundChunk;
  1711.  ULONG                   ChunkLen;
  1712.  REGISTER UWORD          BytesPerRow,bpr,y,ByteCount,h,i;
  1713.  REGISTER UBYTE          b;
  1714.  ULONG                   dest;
  1715.  register struct Screen *scr;
  1716.  struct BMHD             bmhd;
  1717.  struct CAMG             camg;
  1718.  struct CRNG             crng;
  1719.  struct ColReg           Farben[32];
  1720.  UWORD                   AnzFarben;
  1721.  struct ColReg           Farbe;
  1722.  struct RInfo           *fh;
  1723.  struct RInfo            ri;
  1724.  
  1725.  ri.Memory=mem;
  1726.  ri.Pos=0;
  1727.  ri.Max=len;
  1728.  fh=&ri;
  1729.  
  1730.  Lesen(fh,&Buffer,12); 
  1731.  
  1732.  if(strncmp(&Buffer[0],"FORM",4)!=0)
  1733.   { InfoRequest("Bild hat kein IFF-Format!");
  1734.      return(FALSE); }
  1735.  if(strncmp(&Buffer[8],"ILBM",4)!=0)
  1736.   { InfoRequest("Bild hat kein ILBM-Format!");
  1737.    return(FALSE); }
  1738.  
  1739.  BMHDFlag=FALSE;
  1740.  BODYFlag=FALSE;
  1741.  CAMGFlag=FALSE;
  1742.  CMAPFlag=FALSE;
  1743.  CRNGFlag=FALSE;
  1744.  
  1745. Loop:
  1746.  FoundChunk=FALSE;
  1747.  l=Lesen(fh,&Buffer,8);
  1748.  if((l==0)||((BMHDFlag==TRUE)&&(BODYFlag==TRUE)&&(CMAPFlag==TRUE)))
  1749.   {
  1750.    if((BMHDFlag==TRUE)&&(BODYFlag==TRUE)&&(CMAPFlag==TRUE))
  1751.     {
  1752.      ShowTitle(scr,FALSE);
  1753.  
  1754.      if(CRNGFlag==TRUE)
  1755.       {
  1756.        if(crng.active!=0)
  1757.         {
  1758.          h=crng.rate/273;
  1759.          if(h==0) h=1;
  1760.          y=50/h;
  1761.          while((MouseButton())==0)
  1762.           {
  1763.            Farbe.Red=Farben[crng.low].Red;
  1764.            Farbe.Green=Farben[crng.low].Green;
  1765.            Farbe.Blue=Farben[crng.low].Blue;
  1766.            for(i=crng.low;i<crng.high;i++)
  1767.             {
  1768.              Farben[i].Red=Farben[i+1].Red;
  1769.              Farben[i].Green=Farben[i+1].Green;
  1770.              Farben[i].Blue=Farben[i+1].Blue;
  1771.             }
  1772.            Farben[crng.high].Red=Farbe.Red;
  1773.            Farben[crng.high].Green=Farbe.Green;
  1774.            Farben[crng.high].Blue=Farbe.Blue;
  1775.            for(i=crng.low;i<crng.high;i++)
  1776.             {
  1777.              SetRGB4(&scr->ViewPort,i,Farben[i].Red,
  1778.                                       Farben[i].Green,
  1779.                                       Farben[i].Blue);
  1780.             }
  1781.            Delay(y);
  1782.           }
  1783.         }
  1784.       }
  1785.      else
  1786.       {
  1787.        while((MouseButton())==0)
  1788.          Delay(5);
  1789.       }
  1790.  
  1791.      CloseScreen(scr);
  1792.      return(TRUE);
  1793.     }
  1794.    else
  1795.     {
  1796.      if((BMHDFlag==TRUE)||(BODYFlag==TRUE)||(CMAPFlag==TRUE))
  1797.       {
  1798.        if(BMHDFlag==FALSE) InfoRequest("Bild hat keinen BMHD-Chunk!");
  1799.        else if(BODYFlag==FALSE) InfoRequest("Bild hat keinen BODY-Chunk!");
  1800.        else if(CMAPFlag==FALSE) InfoRequest("Bild hat keinen CMAP-Chunk!");
  1801.        if(scr!=NULL) CloseScreen(scr);
  1802.        return(FALSE);
  1803.       }
  1804.     }
  1805.   }
  1806.  ChunkLen=Buffer[4]*16777216+Buffer[5]*65536+Buffer[6]*256+Buffer[7];
  1807.  if(strncmp(&Buffer,"BMHD",4)==0)
  1808.   {
  1809.    Lesen(fh,&bmhd,ChunkLen);
  1810.    if(bmhd.Compression>1)
  1811.     {
  1812.      InfoRequest("Unbekannte Kompressionsmethode!");
  1813.      return(FALSE);
  1814.     }
  1815.    ns.LeftEdge   = 0;
  1816.    ns.TopEdge    = 0;
  1817.    ns.Width      = bmhd.Width;
  1818.    ns.Height     = bmhd.Height;
  1819.    ns.Depth      = bmhd.BitPlanes;
  1820.    ns.DetailPen  = 1;
  1821.    ns.BlockPen   = 0;
  1822.    if(CAMGFlag==TRUE)
  1823.     {
  1824.      ns.ViewModes = camg.ViewModes;
  1825.     }
  1826.    else
  1827.     {
  1828.      if(ns.Width>320) ns.ViewModes |= HIRES;
  1829.      if(ns.Height>256) ns.ViewModes |= LACE;
  1830.     }
  1831.    ns.Type         = CUSTOMSCREEN;
  1832.    ns.Font         = NULL;
  1833.    ns.DefaultTitle = "Ende mit Mausklick";
  1834.    ns.Gadgets      = NULL;
  1835.    ns.CustomBitMap = NULL;
  1836.    scr=OpenScreen(&ns);
  1837.    if(scr==NULL)
  1838.     {
  1839.      InfoRequest("Kann Screen nicht öffnen!");
  1840.      return(FALSE);
  1841.     }
  1842.    BytesPerRow=bmhd.Width/8;
  1843.    bpr=(bmhd.w+1)/8;
  1844.    h=bmhd.h+1;
  1845.    BMHDFlag=TRUE;
  1846.    FoundChunk=TRUE;
  1847.   }
  1848.  if(strncmp(&Buffer,"CMAP",4)==0)
  1849.   {
  1850.    if(BMHDFlag==FALSE)
  1851.     { InfoRequest("BMHD-Chunk muß vor CMAP-Chunk stehen!");
  1852.       return(FALSE); }
  1853.  
  1854.    AnzFarben=ColorCount[bmhd.BitPlanes];
  1855.    for(i=0;i<AnzFarben;i++)
  1856.     {
  1857.      Lesen(fh,&Farbe,3);
  1858.      Farben[i].Red=Farbe.Red>>4;
  1859.      Farben[i].Green=Farbe.Green>>4;
  1860.      Farben[i].Blue=Farbe.Blue>>4;
  1861.      SetRGB4(&scr->ViewPort,i,Farben[i].Red,
  1862.                               Farben[i].Green,
  1863.                               Farben[i].Blue);
  1864.     }
  1865.    CMAPFlag   = TRUE;
  1866.    FoundChunk = TRUE;
  1867.   }
  1868.  if(strncmp(&Buffer,"BODY",4)==0)
  1869.   {
  1870.    if(BMHDFlag==FALSE)
  1871.     { InfoRequest("BMHD-Chunk muß vor BODY-Chunk stehen!");
  1872.       return(FALSE); }
  1873.  
  1874.    for(y=0;y<h;y++)
  1875.     {
  1876.      for(b=0;b<bmhd.BitPlanes;b++)
  1877.       {
  1878.        ByteCount=0;
  1879.        dest=(ULONG)((ULONG)(scr->RastPort.BitMap->Planes[b])+y*BytesPerRow+bmhd.x);
  1880.        if(bmhd.Compression==0)
  1881.         {
  1882.          Lesen(fh,dest,bpr);
  1883.         }
  1884.        else
  1885.         {
  1886.          while(ByteCount<bpr)
  1887.           {
  1888.            Lesen(fh,&Buffer[0],1);
  1889.            if(Buffer[0]<128)
  1890.             {
  1891.              Lesen(fh,dest+(ULONG)ByteCount,Buffer[0]+1);
  1892.              ByteCount += Buffer[0]+1;
  1893.             }
  1894.            if(Buffer[0]>128)
  1895.             {
  1896.              Lesen(fh,&Buffer[1],1);
  1897.              for(i=ByteCount;i<(ByteCount+(257-Buffer[0]));i++)
  1898.                { *((UBYTE *)dest+(UBYTE *)i)=Buffer[1]; }
  1899.              ByteCount += 257-Buffer[0];
  1900.             }
  1901.           }
  1902.         }
  1903.       }
  1904.     }
  1905.    BODYFlag   = TRUE;
  1906.    FoundChunk = TRUE;
  1907.   }
  1908.  if(strncmp(&Buffer,"CAMG",4)==0)
  1909.   {
  1910.    Lesen(fh,&camg,ChunkLen);
  1911.    if(BMHDFlag==FALSE)
  1912.     { InfoRequest("BMHD-Chunk muß vor CAMG-Chunk stehen!");
  1913.       return(FALSE); }
  1914.    scr->ViewPort.Modes=camg.ViewModes;
  1915.    RemakeDisplay();
  1916.    CAMGFlag   = TRUE;
  1917.    FoundChunk = TRUE;
  1918.   }
  1919.  if(strncmp(&Buffer,"CRNG",4)==0)
  1920.   {
  1921.    if(CRNGFlag==FALSE)
  1922.     {
  1923.      Lesen(fh,&crng,ChunkLen);
  1924.      CRNGFlag   = TRUE;
  1925.      FoundChunk = TRUE;
  1926.     }
  1927.   }
  1928.  if(FoundChunk==FALSE)
  1929.   {
  1930.    Jump(fh,ChunkLen);
  1931.    if(ChunkLen & 1) Jump(fh,1);
  1932.   }
  1933.  goto Loop;
  1934. }
  1935.  
  1936.  
  1937. BOOL ShowPicture(name)
  1938.  UBYTE *name;
  1939. {
  1940.  REGISTER UBYTE             *mem;
  1941.  REGISTER ULONG              size;
  1942.  register struct FileHandle *fh;
  1943.  
  1944.  fh=Open(name,MODE_OLDFILE);
  1945.  if(fh!=NULL)
  1946.   {
  1947.    Seek(fh,0,OFFSET_END);
  1948.    size=Seek(fh,0,OFFSET_BEGINNING);
  1949.    mem=AllocMem(size,MEMF_CLEAR|MEMF_PUBLIC);
  1950.    if(mem!=NULL)
  1951.     {
  1952.      DisplayPicture(mem,size);
  1953.      FreeMem(mem,size);
  1954.     }
  1955.   }
  1956.  else return(FALSE);
  1957.  return(TRUE);
  1958. }
  1959.  
  1960. #asm
  1961.    public _MouseButton
  1962. _MouseButton:
  1963.    btst #6,$bfe001
  1964.    bne 1$
  1965.    move.l #1,d0
  1966.    rts
  1967. 1$:
  1968.    clr.l d0
  1969.    rts
  1970. #endasm
  1971.  
  1972.  
  1973. VOID AddPage(hd)
  1974.  struct HelpData *hd;
  1975. {
  1976.  REGISTER UBYTE i;
  1977.  
  1978.  hd->ShowLastPageBack=0;
  1979.  hd->LastPageSelect=hd->LastPagePos;
  1980.  if(hd->LastPagePos<PAGE_MEMORY)
  1981.   {
  1982.    hd->LastPage[hd->LastPagePos]=hd->Page;
  1983.    hd->LastPagePos++;
  1984.   }
  1985.  else
  1986.   {
  1987.    for(i=0;i<PAGE_MEMORY;i++)
  1988.     {
  1989.      hd->LastPage[i]=hd->LastPage[i+1];
  1990.     }
  1991.    hd->LastPage[PAGE_MEMORY-1]=hd->Page;
  1992.    hd->LastPageSelect=PAGE_MEMORY-1;
  1993.   }
  1994. }
  1995.  
  1996.